{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 大模型根据用户输入生成cypher查询语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from typing import Literal\n",
    "from py2neo import Graph\n",
    "from langchain_openai import ChatOpenAI\n",
    "import os\n",
    "from typing import TypedDict, Annotated\n",
    "import operator\n",
    "from IPython.display import Image\n",
    "\n",
    "from langchain_core.messages import (\n",
    "    AnyMessage,\n",
    "    SystemMessage,\n",
    "    HumanMessage,\n",
    "    ToolMessage,\n",
    "    AIMessage,\n",
    ")\n",
    "from langgraph.graph import StateGraph, END, START\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "CYPHER_WRITER_PROMPT = \"\"\"\n",
    "你是一位知识图谱专家，擅长编写 Cypher 查询语句。你的任务是根据用户的需求，利用下述 `Company` 节点的属性和别名，生成精准的 Cypher 查询语句。\n",
    "\n",
    "以下是 `Company` 节点的属性及其对应的别名（用户可能使用这些别名来描述需求）：\n",
    "\n",
    "- `CompanyName` -> 企业名称\n",
    "- `EnglishName` -> 英文名称\n",
    "- `UnifiedSocialCreditCode` -> 统一社会信用代码\n",
    "- `CompanyType` -> 企业类型\n",
    "- `OperatingStatus` -> 经营状态\n",
    "- `EstablishmentDate` -> 成立日期\n",
    "- `ApprovalDate` -> 核准日期\n",
    "- `LegalRepresentative` -> 法定代表人\n",
    "- `RegisteredCapital` -> 注册资本\n",
    "- `PaidUpCapital` -> 实缴资本\n",
    "- `InsuredEmployees` -> 参保人数\n",
    "- `CompanySize` -> 公司规模\n",
    "- `BusinessScope` -> 经营范围\n",
    "- `RegisteredAddress` -> 注册地址\n",
    "- `BusinessTerm` -> 营业期限\n",
    "- `TaxpayerIdentificationNumber` -> 纳税人识别号\n",
    "- `BusinessRegistrationNumber` -> 工商注册号\n",
    "- `OrganizationCode` -> 组织机构代码\n",
    "- `TaxpayerQualification` -> 纳税人资质\n",
    "- `FormerName` -> 曾用名\n",
    "- `Province` -> 所属省份\n",
    "- `City` -> 所属城市\n",
    "- `District` -> 所属区县\n",
    "- `WebsiteLink` -> 网站链接\n",
    "- `Industry` -> 所属行业\n",
    "- `PrimaryIndustryCategory` -> 一级行业分类\n",
    "- `RegistrationAuthority` -> 登记机关\n",
    "- `Longitude` -> 经度\n",
    "- `Latitude` -> 纬度\n",
    "- `WebsiteURL` -> 网址\n",
    "- `HydrogenIndustryChainNode` -> 氢能产业链节点\n",
    "- `ReasonForInclusionInChain` -> 上链原因\n",
    "\n",
    "其中HydrogenIndustryChainNode包含：制氢、储氢和运输、加氢站、交通领域、工业领域、发电领域、建筑领域\n",
    "\n",
    "请使用这些属性和对应的别名，依据用户的具体需求，生成最为合适的 Cypher 查询语句， 生成的每个cypher查询语句都以;结尾。\n",
    "\"\"\".lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'制氢、储氢和运输、加氢站、交通领域、工业领域、发电领域、建筑领域、其他'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LABEL_NAMES = [\n",
    "    \"制氢\",\n",
    "    \"储氢和运输\",\n",
    "    \"加氢站\",\n",
    "    \"交通领域\",\n",
    "    \"工业领域\",\n",
    "    \"发电领域\",\n",
    "    \"建筑领域\",\n",
    "    \"其他\",\n",
    "]\n",
    "\"、\".join(LABEL_NAMES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "// 查询制氢领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '制氢'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询储氢和运输领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '储氢和运输'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询加氢站领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '加氢站'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询交通领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '交通领域'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询工业领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '工业领域'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询发电领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '发电领域'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;  // 查询建筑领域企业数量 MATCH (c:Company {HydrogenIndustryChainNode: '建筑领域'}) RETURN c.Province AS Province, count(c) AS CompanyCount ORDER BY Province;\n"
     ]
    }
   ],
   "source": [
    "q = \"逐个输出每个省在 制氢、储氢和运输、加氢站、交通领域、工业领域、发电领域、建筑领域 上的企业数量？\"\n",
    "res = cypher_query_generator(q)\n",
    "print(res.replace(\"\\n\", \" \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'你是一位知识图谱专家，擅长编写 Cypher 查询语句。你的任务是根据用户的需求，利用下述 `Company` 节点的属性和别名，生成精准的 Cypher 查询语句。\\n\\n以下是 `Company` 节点的属性及其对应的别名（用户可能使用这些别名来描述需求）：\\n\\n- `CompanyName` -> 企业名称\\n- `EnglishName` -> 英文名称\\n- `UnifiedSocialCreditCode` -> 统一社会信用代码\\n- `CompanyType` -> 企业类型\\n- `OperatingStatus` -> 经营状态\\n- `EstablishmentDate` -> 成立日期\\n- `ApprovalDate` -> 核准日期\\n- `LegalRepresentative` -> 法定代表人\\n- `RegisteredCapital` -> 注册资本\\n- `PaidUpCapital` -> 实缴资本\\n- `InsuredEmployees` -> 参保人数\\n- `CompanySize` -> 公司规模\\n- `BusinessScope` -> 经营范围\\n- `RegisteredAddress` -> 注册地址\\n- `BusinessTerm` -> 营业期限\\n- `TaxpayerIdentificationNumber` -> 纳税人识别号\\n- `BusinessRegistrationNumber` -> 工商注册号\\n- `OrganizationCode` -> 组织机构代码\\n- `TaxpayerQualification` -> 纳税人资质\\n- `FormerName` -> 曾用名\\n- `Province` -> 所属省份\\n- `City` -> 所属城市\\n- `District` -> 所属区县\\n- `WebsiteLink` -> 网站链接\\n- `Industry` -> 所属行业\\n- `PrimaryIndustryCategory` -> 一级行业分类\\n- `SecondaryIndustryCategory` -> 二级行业分类\\n- `TertiaryIndustryCategory` -> 三级行业分类\\n- `RegistrationAuthority` -> 登记机关\\n- `Longitude` -> 经度\\n- `Latitude` -> 纬度\\n- `WebsiteURL` -> 网址\\n- `HydrogenIndustryChainNode` -> 氢能产业链节点\\n- `ReasonForInclusionInChain` -> 上链原因\\n\\n请使用这些属性和对应的别名，依据用户的具体需求，生成最为合适的 Cypher 查询语句。\\n请你查看湖北省有多少家氢能企业？'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CYPHER_WRITER_PROMPT + \"请你查看湖北省有多少家氢能企业？\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "memory = MemorySaver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AgentState(TypedDict):\n",
    "    messages: Annotated[list[AnyMessage], operator.add]  # 消息列表\n",
    "    query: str  # 当前查询\n",
    "    cyphers: list[str]  # 当前全部的cypher查询语句\n",
    "    cur_query_idx: int  # 当前cypher的索引\n",
    "    cur_cypher: str  # 当前cypher查询语句, 因为有modify_cypher, 所以需要保存\n",
    "    except_cnt: int  # 异常次数, 超过3次则停止\n",
    "    cypher_result: list\n",
    "    modify_cypher: str  # 修改后的cypher\n",
    "    cypher_err: str  # cypher执行错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Neo4jAgent:\n",
    "    def __init__(self, checkpointer=None, examples=[]):\n",
    "        self.examples = examples\n",
    "        graph = StateGraph(AgentState)\n",
    "\n",
    "        graph.set_entry_point(\"human_input\")\n",
    "        graph.add_node(\"human_input\", self.human_input)\n",
    "        graph.add_node(\"neo4j_chat\", self.neo4j_chat)\n",
    "        graph.add_node(\"other_chat\", self.other_chat)\n",
    "        graph.add_node(\"run_cypher\", self.run_cypher)\n",
    "        graph.add_node(\"modify_cypher\", self.modify_cypher)\n",
    "        graph.add_node(\"cypher_output\", self.cypher_output)\n",
    "\n",
    "        graph.add_edge(\"neo4j_chat\", \"run_cypher\")\n",
    "\n",
    "        # graph.add_edge(\"run_cypher\", \"human_input\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        graph.add_edge(\"other_chat\", \"human_input\")\n",
    "        graph.add_edge(\"modify_cypher\", \"run_cypher\")\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"human_input\",\n",
    "            self.router,\n",
    "            {\"neo4j_chat\": \"neo4j_chat\", \"other_chat\": \"other_chat\", \"__end__\": END},\n",
    "        )\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"run_cypher\",\n",
    "            self.run_cypher_router,\n",
    "            {\"cypher_output\": \"cypher_output\", \"modify_cypher\": \"modify_cypher\", \"human_input\":\"human_input\"},\n",
    "        )\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"cypher_output\",\n",
    "            self.cypher_output_router,\n",
    "            {\"run_cypher\": \"run_cypher\", \"human_input\":\"human_input\"},\n",
    "        )\n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "        self.graph = graph.compile(checkpointer=checkpointer)\n",
    "\n",
    "        self.llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
    "        self.driver = Graph(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "\n",
    "    def human_input(self, state: AgentState):\n",
    "        message = input(\"Human> \")\n",
    "        # TODO: 默认存储的就是氢能企业，为了大模型在属性里匹配氢能，故目前暂定删去用户输入中的氢能。\n",
    "        message = message.replace(\"氢能\", \"\")\n",
    "        return {\n",
    "            \"messages\": [HumanMessage(message)],\n",
    "            \"query\": message,\n",
    "            \"cyphers\": [],\n",
    "            \"except_cnt\": 0,\n",
    "            \"cur_query_idx\": 0,\n",
    "            \"cypher_result\": [],\n",
    "            \"modify_cypher\": \"\",\n",
    "            \"cur_cypher\":\"\",\n",
    "        }\n",
    "\n",
    "    def neo4j_chat(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        根据用户输入，生成cypher查询语句\n",
    "        \"\"\"\n",
    "        content = state[\"messages\"][-1].content\n",
    "        # TODO： cypher_query_generator, 能够提取出多个cypher，并返回一个列表\n",
    "\n",
    "        global CYPHER_WRITER_PROMPT\n",
    "        response = self.llm.invoke(CYPHER_WRITER_PROMPT + content).content\n",
    "        cyphers = re.findall(r\"match(.+?);\", response, re.DOTALL)\n",
    "        return {\n",
    "            \"cyphers\": cyphers,\n",
    "            \"except_cnt\": 0,\n",
    "            \"cur_query_idx\": 0,\n",
    "        }\n",
    "\n",
    "    def run_cypher(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        遇到异常让大模型重新生成，如果一直异常怎么办？一直浪费token? 必须限制\n",
    "        \"\"\"\n",
    "        cyphers = state[\"cyphers\"]\n",
    "        except_cnt = state[\"except_cnt\"]\n",
    "        cur_query_idx = state[\"cur_query_idx\"]\n",
    "        cur_cypher = cyphers[cur_query_idx]\n",
    "        query = state[\"query\"]\n",
    "\n",
    "        modify_cypher = state[\"modify_cypher\"]\n",
    "        if modify_cypher:\n",
    "            cur_cypher = modify_cypher\n",
    "\n",
    "        try:\n",
    "            res = self.driver.run(cur_cypher)\n",
    "            return {\n",
    "                \"cypher_result\":res, \n",
    "                \"modify_cypher\": \"\", # 清空 modify_cypher\n",
    "                \"cur_cypher\" : cur_cypher,\n",
    "                \"cur_query_idx\": cur_query_idx + 1,\n",
    "                \"except_cnt\": 0,\n",
    "                }\n",
    "        \n",
    "        except Exception as e:\n",
    "            # 提交错误信息给 modify_cypher\n",
    "            if except_cnt < 3:\n",
    "                return {\n",
    "                    \"modify_cypher\": cur_cypher,\n",
    "                    \"cypher_err\": str(e),\n",
    "                    \"except_cnt\": except_cnt + 1\n",
    "                    }\n",
    "            else:\n",
    "                # 如果连续3次异常，则返回无法解决该问题, back to human_input\n",
    "                response = f\"在解决该问题: {query}。\\n出现了以下错误：{str(e)}，\\n在经过3次尝试后，依然无法解决该问题。\"\n",
    "                return {\n",
    "                    \"messages\":[AIMessage(content=response)],\n",
    "                    # \"except_cnt\": 0, # 重置异常计数\n",
    "                    \"except_cnt\": except_cnt + 1,\n",
    "                    \"modify_cypher\": \"\", # 清空 modify_cypher, give up\n",
    "                }\n",
    "        \n",
    "\n",
    "    def modify_cypher(self, state: AgentState) -> str:\n",
    "        modify_cypher = state[\"modify_cypher\"]\n",
    "        cypher_err = state[\"cypher_err\"]\n",
    "        \n",
    "        MODIFY_PROMPT = \"在运行cypher语句时出现了异常，请修改cypher语句，使其能够正常运行。异常信息为：{cypher_err}，cypher语句为：{modify_cypher}。\"\n",
    "        content = self.llm.invoke(MODIFY_PROMPT.format(cypher_err=cypher_err, modify_cypher=modify_cypher)).content\n",
    "        cypher = re.findall(r\"match(.+?);\", content, re.DOTALL)[0]\n",
    "        return {\n",
    "            \"modify_cypher\": cypher\n",
    "        }\n",
    "\n",
    "\n",
    "    def router(self, state) -> Literal[\"neo4j_chat\", \"other_chat\", \"__end__\"]:\n",
    "\n",
    "        content = state[\"messages\"][-1].content\n",
    "        keywords = [\"产业\", \"企业\", \"公司\", \"数量\"]\n",
    "\n",
    "        for kw in keywords:\n",
    "            if kw in content:\n",
    "                return \"neo4j_chat\"\n",
    "\n",
    "        if \"q\" == content or \"exit\" == content:\n",
    "            return \"__end__\"\n",
    "\n",
    "        return \"other_chat\"\n",
    "    \n",
    "\n",
    "    def cypher_output_router(self, state: AgentState) -> Literal[\"run_cypher\", \"human_input\"]:\n",
    "        \n",
    "        cur_query_idx = state[\"cur_query_idx\"]\n",
    "        pass\n",
    "\n",
    "    \n",
    "    def run_cypher_router(self, state: AgentState) -> Literal[\"cypher_output\", \"modify_cypher\", \"human_input\"]:\n",
    "        cypher_result = state.get(\"cypher_result\", [])\n",
    "        modify_cypher = state.get(\"modify_cypher\", \"\")\n",
    "        if cypher_result:\n",
    "            return \"cypher_output\"\n",
    "        elif modify_cypher:\n",
    "            \"modify_cypher\"\n",
    "        else:\n",
    "            return \"human_input\"\n",
    "\n",
    "\n",
    "    def other_chat(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        换成用户有输入，当用户输入 q、exit 退出\n",
    "        * 搜索引擎\n",
    "        * 图数据库\n",
    "        * 退出\n",
    "        条件怎么写？\n",
    "        \"\"\"\n",
    "        # messages = [SystemMessage(self.system)] + self.examples + state[\"messages\"]\n",
    "        content = state[\"messages\"][-1].content\n",
    "        print(content)\n",
    "        response = self.model.invoke(content).content\n",
    "        return {\"messages\": [AIMessage(content=response)]}\n",
    "\n",
    "    def cypher_output(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        * 如果只有一条结果，直接返回结果；\n",
    "        * 如果有多个结果，根据用户的问题和cypher，创建文件名，保存结果；\n",
    "        \"\"\"\n",
    "        query = state[\"query\"]\n",
    "        cypher_results = state[\"cypher_results\"]\n",
    "\n",
    "        cyphers = state[\"cyphers\"]\n",
    "        except_cnt = state[\"except_cnt\"]\n",
    "        cur_query_idx = state[\"cur_query_idx\"]\n",
    "        cypher_query = cyphers[cur_query_idx]\n",
    "\n",
    "        data = list(cypher_results.data())\n",
    "\n",
    "        if len(data) == 1:\n",
    "            return {\"messages\": [AIMessage(content=data)]}\n",
    "\n",
    "        # 数量大于1的导出到文件中\n",
    "        # 选取一个文件名\n",
    "        filename = \"\"\n",
    "        self.llm.invoke(\"请根据问题{}和cypher{}生成一个文件名。你只需要输出文件名即可，不需要输出后缀和其他内容。\".format(query, cypher_query))\n",
    "\n",
    "        for item in data:\n",
    "            for k, v in item.items():\n",
    "                # d = dict(v)\n",
    "                if not isinstance(v, str) and not isinstance(v, int):\n",
    "                    print(dict(v))\n",
    "                else:\n",
    "                    print(v, type(v))\n",
    "\n",
    "        return {\n",
    "            \"messages\": [AIMessage(content=\"cypher_output\")],\n",
    "            \"\"\n",
    "            }\n",
    "\n",
    "    def draw_graph(self):\n",
    "        return Image(self.graph.get_graph().draw_png())\n",
    "\n",
    "\n",
    "neo4j_agent = Neo4jAgent(checkpointer=memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neo4j_agent.draw_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "events = neo4j_agent.graph.stream(\n",
    "    {\"messages\": [None]},\n",
    "    config,\n",
    "    stream_mode=\"values\",\n",
    ")\n",
    "\n",
    "for event in events:\n",
    "    if \"messages\" in event:\n",
    "        if event[\"messages\"][-1]:\n",
    "            event[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import os\n",
    "import time\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "\n",
    "from typing import Literal, Dict, Any\n",
    "from py2neo import Graph\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "from typing import TypedDict, Annotated\n",
    "import operator\n",
    "from IPython.display import Image\n",
    "\n",
    "from langchain_core.messages import (\n",
    "    AnyMessage,\n",
    "    SystemMessage,\n",
    "    HumanMessage,\n",
    "    ToolMessage,\n",
    "    AIMessage,\n",
    ")\n",
    "from langgraph.graph import StateGraph, END, START\n",
    "\n",
    "CYPHER_WRITER_PROMPT = \"\"\"\n",
    "你是一位知识图谱专家，擅长编写 Cypher 查询语句。你的任务是根据用户的需求，利用下述 `Company` 节点的属性和别名，生成精准的 Cypher 查询语句。\n",
    "\n",
    "以下是 `Company` 节点的属性及其对应的别名（用户可能使用这些别名来描述需求）：\n",
    "\n",
    "- `CompanyName` -> 企业名称\n",
    "- `EnglishName` -> 英文名称\n",
    "- `UnifiedSocialCreditCode` -> 统一社会信用代码\n",
    "- `CompanyType` -> 企业类型\n",
    "- `OperatingStatus` -> 经营状态\n",
    "- `EstablishmentDate` -> 成立日期\n",
    "- `ApprovalDate` -> 核准日期\n",
    "- `LegalRepresentative` -> 法定代表人\n",
    "- `RegisteredCapital` -> 注册资本\n",
    "- `PaidUpCapital` -> 实缴资本\n",
    "- `InsuredEmployees` -> 参保人数\n",
    "- `CompanySize` -> 公司规模\n",
    "- `BusinessScope` -> 经营范围\n",
    "- `RegisteredAddress` -> 注册地址\n",
    "- `BusinessTerm` -> 营业期限\n",
    "- `TaxpayerIdentificationNumber` -> 纳税人识别号\n",
    "- `BusinessRegistrationNumber` -> 工商注册号\n",
    "- `OrganizationCode` -> 组织机构代码\n",
    "- `TaxpayerQualification` -> 纳税人资质\n",
    "- `FormerName` -> 曾用名\n",
    "- `Province` -> 所属省份\n",
    "- `City` -> 所属城市\n",
    "- `District` -> 所属区县\n",
    "- `WebsiteLink` -> 网站链接\n",
    "- `Industry` -> 所属行业\n",
    "- `PrimaryIndustryCategory` -> 一级行业分类\n",
    "- `RegistrationAuthority` -> 登记机关\n",
    "- `Longitude` -> 经度\n",
    "- `Latitude` -> 纬度\n",
    "- `WebsiteURL` -> 网址\n",
    "- `HydrogenIndustryChainNode` -> 氢能产业链节点\n",
    "- `ReasonForInclusionInChain` -> 上链原因\n",
    "\n",
    "其中HydrogenIndustryChainNode包含：制氢、储氢和运输、加氢站、交通领域、工业领域、发电领域、建筑领域\n",
    "\n",
    "请使用这些属性和对应的别名，依据用户的具体需求，生成最为合适的 Cypher 查询语句， 生成的每个cypher查询语句都以;结尾。\n",
    "\"\"\".lstrip()\n",
    "\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "\n",
    "memory = MemorySaver()\n",
    "\n",
    "\n",
    "class AgentState(TypedDict):\n",
    "    messages: Annotated[list[AnyMessage], operator.add]  # 消息列表\n",
    "    query: str  # 当前查询\n",
    "    cyphers: list[str]  # 当前全部的cypher查询语句\n",
    "    cur_query_idx: int  # 当前cypher的索引\n",
    "    cur_cypher: str  # 当前cypher查询语句, 因为有modify_cypher, 所以需要保存\n",
    "    except_cnt: int  # 异常次数, 超过3次则停止\n",
    "    cypher_result: list\n",
    "    modify_cypher: str  # 修改后的cypher\n",
    "    cypher_err: str  # cypher执行错误\n",
    "\n",
    "\n",
    "class Neo4jAgent:\n",
    "    def __init__(self, checkpointer=None, examples=[]):\n",
    "        self.examples = examples\n",
    "        graph = StateGraph(AgentState)\n",
    "\n",
    "        graph.set_entry_point(\"human_input\")\n",
    "        graph.add_node(\"human_input\", self.human_input)\n",
    "        graph.add_node(\"neo4j_chat\", self.neo4j_chat)\n",
    "        graph.add_node(\"other_chat\", self.other_chat)\n",
    "        graph.add_node(\"run_cypher\", self.run_cypher)\n",
    "        graph.add_node(\"teacher_chat\", self.teacher_chat)\n",
    "        graph.add_node(\"cypher_output\", self.cypher_output)\n",
    "\n",
    "        graph.add_edge(\"neo4j_chat\", \"run_cypher\")\n",
    "\n",
    "        # graph.add_edge(\"run_cypher\", \"human_input\")\n",
    "\n",
    "        graph.add_edge(\"other_chat\", \"human_input\")\n",
    "        graph.add_edge(\"teacher_chat\", \"run_cypher\")\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"human_input\",\n",
    "            self.router,\n",
    "            {\"neo4j_chat\": \"neo4j_chat\", \"other_chat\": \"other_chat\", \"__end__\": END},\n",
    "        )\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"run_cypher\",\n",
    "            self.run_cypher_router,\n",
    "            {\"cypher_output\": \"cypher_output\", \"teacher_chat\": \"teacher_chat\", \"human_input\": \"human_input\"},\n",
    "        )\n",
    "\n",
    "        graph.add_conditional_edges(\n",
    "            \"cypher_output\",\n",
    "            self.cypher_output_router,\n",
    "            {\"run_cypher\": \"run_cypher\", \"human_input\": \"human_input\"},\n",
    "        )\n",
    "\n",
    "        self.graph = graph.compile(checkpointer=checkpointer)\n",
    "\n",
    "        # self.llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
    "        self.llm = ChatOpenAI(\n",
    "            model=\"gpt-4o-mini\",\n",
    "            base_url='https://api.chatfire.cn/v1',\n",
    "            api_key=\"sk-uzqOOLE2fCDUwYEv260fE0DdCa91484090D20291DfB11e99\",\n",
    "            temperature=0\n",
    "        )\n",
    "        self.driver = Graph(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "\n",
    "    def human_input(self, state: AgentState):\n",
    "        message = input(\"Human> \")\n",
    "        # TODO: 默认存储的就是氢能企业，为了大模型在属性里匹配氢能，故目前暂定删去用户输入中的氢能。\n",
    "        message = message.replace(\"氢能\", \"\")\n",
    "        return {\n",
    "            \"messages\": [HumanMessage(message)],\n",
    "            \"query\": message,\n",
    "            \"cyphers\": [],\n",
    "            \"except_cnt\": 0,\n",
    "            \"cur_query_idx\": 0,\n",
    "            \"cypher_result\": [],\n",
    "            \"modify_cypher\": \"\",\n",
    "            \"cur_cypher\": \"\",\n",
    "        }\n",
    "\n",
    "    def neo4j_chat(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        根据用户输入，生成cypher查询语句\n",
    "        \"\"\"\n",
    "        content = state[\"messages\"][-1].content\n",
    "        # TODO： cypher_query_generator, 能够提取出多个cypher，并返回一个列表\n",
    "\n",
    "        global CYPHER_WRITER_PROMPT\n",
    "        response = self.llm.invoke(CYPHER_WRITER_PROMPT + content).content\n",
    "        print(\"llm\", response)\n",
    "        # cyphers = re.findall(r\"MATCH(.+?);\", response, re.DOTALL)\n",
    "        cyphers = re.findall(r\"MATCH.+?;\", response, re.DOTALL)\n",
    "        print(\"Cypher Query: \", cyphers)\n",
    "        return {\n",
    "            \"cyphers\": cyphers,\n",
    "            \"except_cnt\": 0,\n",
    "            \"cur_query_idx\": 0,\n",
    "        }\n",
    "\n",
    "    def run_cypher(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        遇到异常让大模型重新生成，如果一直异常怎么办？一直浪费token? 必须限制\n",
    "        \"\"\"\n",
    "        print(\"run_cypher\", state)\n",
    "        cyphers = state[\"cyphers\"]\n",
    "        except_cnt = state[\"except_cnt\"]\n",
    "        cur_query_idx = state[\"cur_query_idx\"]\n",
    "        if cur_query_idx >= len(cyphers):\n",
    "            return {\"messages\": [AIMessage(content=\"无法生成正确的cypher语句，抱歉。\")]}\n",
    "\n",
    "        cur_cypher = cyphers[cur_query_idx]\n",
    "        query = state[\"query\"]\n",
    "\n",
    "        modify_cypher = state[\"modify_cypher\"]\n",
    "        if modify_cypher:\n",
    "            cur_cypher = modify_cypher\n",
    "\n",
    "        try:\n",
    "            res = self.driver.run(cur_cypher)\n",
    "            return {\n",
    "                # \"messages\": [AIMessage(content=res)],\n",
    "                \"cypher_result\": res,\n",
    "                \"modify_cypher\": \"\",  # 清空 modify_cypher\n",
    "                \"cur_cypher\": cur_cypher,\n",
    "                \"cur_query_idx\": cur_query_idx + 1,\n",
    "                \"except_cnt\": 0,\n",
    "            }\n",
    "\n",
    "        except Exception as e:\n",
    "            # 提交错误信息给 modify_cypher\n",
    "            if except_cnt < 3:\n",
    "                return {\n",
    "                    \"modify_cypher\": cur_cypher,\n",
    "                    \"cypher_err\": str(e.args),\n",
    "                    \"except_cnt\": except_cnt + 1\n",
    "                }\n",
    "            else:\n",
    "                # 如果连续3次异常，则返回无法解决该问题, back to human_input\n",
    "                response = f\"在解决该问题: {query}。\\n出现了以下错误：{str(e)}，\\n在经过3次尝试后，依然无法解决该问题。\"\n",
    "                return {\n",
    "                    \"messages\": [AIMessage(content=response)],\n",
    "                    # \"except_cnt\": 0, # 重置异常计数\n",
    "                    \"except_cnt\": except_cnt + 1,\n",
    "                    \"modify_cypher\": \"\",  # 清空 modify_cypher, give up\n",
    "                }\n",
    "\n",
    "    def teacher_chat(self, state: AgentState) -> dict[str, str]:\n",
    "        modify_cypher = state[\"modify_cypher\"]\n",
    "        cypher_err = state[\"cypher_err\"]\n",
    "\n",
    "        MODIFY_PROMPT = \"在运行cypher语句时出现了异常，请修改cypher语句，使其能够正常运行。异常信息为：{cypher_err}，cypher语句为：{modify_cypher}。\"\n",
    "        content = self.llm.invoke(MODIFY_PROMPT.format(cypher_err=cypher_err, modify_cypher=modify_cypher)).content\n",
    "        cypher = re.findall(r\"MATCH(.+?);\", content, re.DOTALL)[0]\n",
    "        return {\n",
    "            \"modify_cypher\": cypher\n",
    "        }\n",
    "\n",
    "    def router(self, state) -> Literal[\"neo4j_chat\", \"other_chat\", \"__end__\"]:\n",
    "\n",
    "        content = state[\"messages\"][-1].content\n",
    "        keywords = [\"产业\", \"企业\", \"公司\", \"数量\"]\n",
    "\n",
    "        for kw in keywords:\n",
    "            if kw in content:\n",
    "                return \"neo4j_chat\"\n",
    "\n",
    "        if \"q\" == content.strip().lower() or \"exit\" == content.strip().lower():\n",
    "            return \"__end__\"\n",
    "\n",
    "        return \"other_chat\"\n",
    "\n",
    "    def run_cypher_router(self, state: AgentState) -> Literal[\"cypher_output\", \"teacher_chat\", \"human_input\"]:\n",
    "        cypher_result = state.get(\"cypher_result\", [])\n",
    "        modify_cypher = state.get(\"modify_cypher\", \"\")\n",
    "        if cypher_result:\n",
    "            return \"cypher_output\"\n",
    "        elif modify_cypher:\n",
    "            \"teacher_chat\"\n",
    "        else:\n",
    "            return \"human_input\"\n",
    "\n",
    "    def cypher_output_router(self, state: AgentState) -> Literal[\"run_cypher\", \"human_input\"]:\n",
    "        cur_query_idx = state[\"cur_query_idx\"]\n",
    "        if cur_query_idx < len(state[\"cyphers\"]):\n",
    "            return \"run_cypher\"\n",
    "        return \"human_input\"\n",
    "\n",
    "    def other_chat(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        换成用户有输入，当用户输入 q、exit 退出\n",
    "        * 搜索引擎\n",
    "        * 图数据库\n",
    "        * 退出\n",
    "        条件怎么写？\n",
    "        \"\"\"\n",
    "        # messages = [SystemMessage(self.system)] + self.examples + state[\"messages\"]\n",
    "        content = state[\"messages\"][-1].content\n",
    "        print(content)\n",
    "        response = self.llm.invoke(content).content\n",
    "        return {\"messages\": [AIMessage(content=response)]}\n",
    "\n",
    "    def cypher_output(self, state: AgentState):\n",
    "        \"\"\"\n",
    "        * 如果只有一条结果，直接返回结果；\n",
    "        * 如果有多个结果，根据用户的问题和cypher，创建文件名，保存结果；\n",
    "        \"\"\"\n",
    "        query = state[\"query\"]\n",
    "        cypher_results = state[\"cypher_result\"]\n",
    "        cur_cypher = state[\"cur_cypher\"]\n",
    "\n",
    "        data = list(cypher_results.data())\n",
    "\n",
    "        if len(data) <= 1:\n",
    "            return {\"messages\": [AIMessage(content=data)]}\n",
    "\n",
    "        # 数量大于1的导出到文件中\n",
    "        # 选取一个文件名\n",
    "        filename = self.llm.invoke(\n",
    "            f\"请根据cypher： {cur_cypher}，生成一个20个字以下的中文文件名。重点关注cypher语句里面提到的中文关键词，使文件名更具描述性。文件名应用下划线分隔，只给出文件名，不需要输出其他内容。\").content\n",
    "        filename = filename.split(\".\")[0]\n",
    "        # 给文件名加时间戳\n",
    "        # current_time = time.strftime(\"%Y%m%d_%H%M%S_%f\", time.localtime())\n",
    "\n",
    "        current_time = datetime.now().strftime(\"%Y%m%d_%H%M%S_%f\")\n",
    "        filename = f\"{filename}_{current_time}\"\n",
    "        pandas_data = []\n",
    "        # for item in data:\n",
    "        #     for k, v in item.items():\n",
    "        #         if not isinstance(v, str) and not isinstance(v, int):\n",
    "        #             pandas_data.append(dict(v))\n",
    "        #         else:\n",
    "        #             print(v, type(v))\n",
    "        pandas_data = data\n",
    "\n",
    "        df = pd.DataFrame(pandas_data)\n",
    "        df.to_csv(name := f\"output/{filename}.csv\", index=False)\n",
    "\n",
    "        return {\n",
    "            \"messages\": [AIMessage(content=f\"文件内容过多，已保存到output目录下，文件名为{name}.csv\")],\n",
    "        }\n",
    "\n",
    "    def draw_graph(self):\n",
    "        return Image(self.graph.get_graph().draw_png())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neo4j_agent = Neo4jAgent(checkpointer=memory)\n",
    "neo4j_agent.draw_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "agent",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
